Block processing in a maximum a posteriori processor for reduced power consumption

ABSTRACT

A maximum a posteriori (MAP) processor employs a block processing technique for the MAP algorithm to provide a parallel architecture that allows for multiple word memory read/write processing and voltage scaling of a given circuit implementation. The block processing technique forms a merged trellis with states having modified branch inputs to provide the parallel structure. When block processing occurs, the trellis may be modified to show transitions from the oldest state at time k−N to the present state at time k. For the merged trellis, the number of states remains the same, but each state receives 2 N  input transitions instead of the two input transitions. Branch metrics associated with the transitions in the merged trellis are cumulative, and are employed for the update process of forward and backward probabilities by the MAP algorithm. During the update process, the read/write operation for an implementation transfers N words of length N for each update operation, but the frequency (and hence, number) of update operations is reduced by a factor of N. Such voltage scaling and multiple word memory read/write may provide reduced power consumption for a given implementation of MAP processor in, for example, a DSP.

BACKGROUND OF THE INVENTION

[0001] 1. Field of the Invention

[0002] The present invention relates to block processing encoded data with a maximum a posteriori (MAP) algorithm by a receiver in a telecommunications system.

[0003] 2. Description of the Related Art

[0004] MAP decoding algorithms are employed for processing data input to a processor for detection and/or decoding operations. The algorithm provides a maximum a posteriori estimate of a state sequence of a finite-state, discrete-time Markov process. The MAP algorithm forms a trellis corresponding to possible states (determined by a portion of received symbol bits in the sequence) for each received channel output value per unit increment in time (i.e., clock cycle).

[0005] States, and transitions between states, of the Markov process spanning an interval of time may be represented by a trellis diagram. The number of bits that a state represents is equivalent to the memory of the Markov process. Thus, probabilities (sometimes of the form of log-likelihood values) are associated with each transition within the trellis, and probabilities are also associated with each decision for a symbol bit in the sequence.

[0006] The processor using the MAP algorithm computes log-likelihood values using a values (forward state probabilities for states in the trellis), and then β values (backward state probabilities in the trellis) after the a values are computed, as described subsequently. The α values are associated with states within the trellis, and these α values are stored in memory. The processor using the MAP algorithm computes values of β, and the α values are then retrieved from memory to compute the final output log-likelihood values. To compute the log-likelihood values, the entire state metric array of α values is stored by the MAP algorithm.

[0007] The variable S_(k) is defined as the set of states of the Markov process at time k, and y_(k) is defined as the noisy channel output sample at time k, the sample sequence of length K=L+1 is defined as the sequence y^(K)=(y₀, y₁, . . . , y_(k), . . . , y_(L)) and, for a data block of length K, probability functions may be defined for the Markov process as given in equations (1) through (3):

α_(s) ^(k) =p(S _(k) =s; y _(k) ^(s))  (1)

β_(s) ^(k) =p(y_(k+1) ^(K) |S _(k) =s)  (2)

γ_(s′,s) ^(k) =p(S _(k) =s; y _(k) |S _(k−1) =s′).  (3)

[0008] where s defines the state S_(k) of the Markov process at time k and s′ defines the state S_(k−1) of the Markov process at time k−1.

[0009] The log-likelihood value L(u_(k)) for a user's symbol u_(k) at time k may then be calculated as given in equation (4): $\begin{matrix} {{L\left( u_{k} \right)} = {{\log \left( \frac{p\left( {u_{k} = {{+ 1} = \left. {- 1} \middle| y_{k}^{K} \right.}} \right)}{p\left( {u_{k} = \left. {- 1} \middle| y_{k}^{K} \right.} \right)} \right)}.}} & (4) \end{matrix}$

[0010]FIG. 1 shows an 8 state trellis from time k−2 to time k. In the figures, the number next to the state indicates the state number i.

[0011] Defining α_(i) ^(k) and β_(i) ^(k) from equations (1) and (2) as the forward and backward probabilities (state metrics) at time k in state i, respectively, and defining γ_(i,j) ^(k) as the branch metric associated with the transition from state i at time k−1 to state j at time k, then, the forward recursion for states is given in equation (5): $\begin{matrix} {{a_{j}^{k} = {\sum\limits_{i\quad \varepsilon \quad S}{\alpha_{i}^{k - 1}\gamma_{i,j}^{k}}}},{{{for}\quad j} = 0},1,\ldots \quad,{M - 1.}} & (5) \end{matrix}$

[0012] where i∈S is a set of states at time k−1 which have a valid transition to the state j at time k, and M is the number of states.

[0013] Similarly, the backward recursion for states is given in equation (6): $\begin{matrix} {{\beta_{i}^{k - 1} = {\sum\limits_{j\quad \varepsilon \quad S}{\beta_{j}^{k}\gamma_{i,j}^{k}}}},{{{for}\quad i} = 0},1,\ldots \quad,{{\cdot M} - 1.}} & (6) \end{matrix}$

[0014] where j∈S is a set of states at time k which have a valid transition from the state i at time k−1.

[0015] Once the forward and backward recursions for states are calculated, from equation (4), the log-likelihood value (also known as reliability value) L(u_(k)) for each user symbol u_(k) is generated as given in equation (7): $\begin{matrix} {{L\left( u_{k} \right)} = {\log \left( \frac{\sum\limits_{{({i,j})}\varepsilon \quad S^{+}}{\alpha_{i}^{k - 1}\gamma_{i,j}^{l}\beta_{j}^{k}}}{\sum\limits_{{({i,j})}\varepsilon \quad S^{-}}{\alpha_{i}^{k - 1}\gamma_{i,j}^{k}\beta_{j}^{k}}} \right)}} & (7) \end{matrix}$

[0016] where a state pair (i, j)∈S⁺ is defined as a pair that has a transition from state i at time k−1 to state j at time k corresponding to the user symbol u_(k)=“1”, and a state pair (i, j)∈S⁻ is similarly defined as a pair that has a transition from state i at time k-i to state j at time k corresponding to the user symbol u_(k)=“−1”.

[0017] The Log MAP algorithm may be defined by substituting A_(j) ^(k)=ln(α_(j) ^(k), B) _(j) ^(k)=ln(β_(j) ^(k)) and Γ_(i,j) ^(k)=ln(γ_(i,j) ^(k)) into the equations (5), (6), and (7). Also, with the relation that ln(expx+expy) is equivalent to max(x,y)+ln(exp(−|x−y|)+1), the Log MAP algorithm may be described as in equations (8) and (9): $\begin{matrix} {A_{j}^{k} = {\max\limits_{i\quad \varepsilon \quad S}{*\left( {a_{i}^{k - 1} + \Gamma_{i,j}^{k}} \right)}}} & (8) \\ {B_{i}^{k - 1} = {\max\limits_{j\quad \varepsilon \quad S}{*\left( {B_{j}^{k - 1} + \Gamma_{i,j}^{k}} \right)}}} & (9) \end{matrix}$

[0018] where max*(x, y) is defined as max(x, y)+ln(exp(−|x−y|)+1).

[0019] As an example, for the forward recursion, A₂ ^(k) in state 2 at time k as shown in FIG. 1 is computed as in equation (10):

A ₂ ^(k)=max*(A ₁ ^(k−1)+Γ_(1,2) ^(k) , A ₅ ^(k−1)+Γ_(5,2) ^(k))  (10)

[0020] When implemented, a MAP algorithm updates the state metrics to compute α_(i) ^(k) and β_(i) ^(k−1) (or their log values for the Log MAP algorithm) based on 1) the current values for the state metrics α_(i) ^(k−1) and β_(i) ^(k) for all i (all states in the set S) and 2) the current sample y_(k). The update occurs for each time k=0, 1, 2, . . . , L, and each update for time k performs a calculation using only the sample corresponding to time k. Thus, the read/write operation for an implementation transfers a single sample word for each update operation at a given rate f.

SUMMARY OF THE INVENTION

[0021] In accordance with embodiments of the present invention, a maximum a posteriori (MAP) processor employs a block processing technique for the MAP algorithm to provide a parallel architecture that allows for multiple word memory read/write processing. The block processing technique forms a merged trellis with states having combined branch inputs to provide the parallel structure. When block processing occurs, the trellis may be modified to show transitions from the oldest state at time k−N to the present state at time k. For the merged trellis, the number of states remains the same, but each state receives ₂N input transitions instead of two input transitions in the original trellis. Branch metrics associated with the transitions in the merged trellis are combinations of branch metrics of the original trellis, and are employed for the update process of forward and backward probabilities by the MAP algorithm. During the update process, the read/write operation for an implementation transfers words of length N for each update operation, but the frequency (and hence, number) of update operations is reduced by a factor of N. Such multiple word memory read/write may provide reduced power consumption for a given implementation of a MAP processor in, for example, a DSP.

[0022] In accordance with an exemplary embodiment of the present invention, probabilities are generated to calculate log-likelihood values in a maximum a posteriori (MAP) processor for samples corresponding to data. A first block of samples and a corresponding set of forward probabilities are retrieved, wherein the block of samples correspond to states of a merged trellis, wherein the merged trellis provides combined probabilities of transition from one or more states at k−N, N an integer greater than 1, to current states at time k as the set of forward probabilities. The set of forward probabilities of the merged trellis for the current state at time k are updated based on the block of samples and the corresponding set of forward probabilities.

BRIEF DESCRIPTION OF THE DRAWINGS

[0023] Other aspects, features, and advantages of the present invention will become more fully apparent from the following detailed description, the appended claims, and the accompanying drawings in which:

[0024]FIG. 1 shows a prior art trellis diagram for a maximum a posteriori (MAP) processor;

[0025] FIGS. 2(a) and 2(b) show modified trellises in accordance with an exemplary embodiment of the present invention for block processing where transitions for two and three sets of previous states and their associated branch metrics are merged;

[0026]FIG. 3 shows an exemplary implementation of memory and memory access for a MAP processor operating in accordance with an exemplary embodiment of the present invention; and

[0027]FIG. 4 shows an exemplary method of MAP detection including updating forward and backward probabilities in accordance with an exemplary embodiment of the present invention.

DETAILED DESCRIPTION

[0028] In accordance with embodiments of the present invention, a maximum a posteriori (MAP) processor employs a block processing technique for the MAP algorithm to provide a parallel architecture that allows for multiple word memory read/write processing of a given circuit implementation. The block processing technique forms a merged trellis with states having modified branch inputs to provide the parallel structure. Such multiple word memory read/write may provide reduced power consumption for a given implementation of MAP processor in, for example, a DSP.

[0029] By combining multiple intermediate time states of a trellis to form a merged trellis from time k−N to time k, the merged trellis structure exhibits a parallel structure. When block processing occurs, more than one (i.e., N>1) received sample may be accounted for at a state in the trellis, and the trellis may be modified to show transitions from the oldest state (at time k−N) to the present state (at time k). During block processing, the state branch and path metrics associated with transitions account for each transition between receive samples. For example, FIG. 2(a) shows a modified trellis for block processing with N=2, and FIG. 2(b) shows a modified trellis for block processing with N=3. For these new merged trellises, the number of states remains the same, but each state takes 2^(N) input transitions instead of the two input transitions.

[0030] Preferred embodiments of the present invention employ the Log MAP algorithm, and the forward and backward probabilities A_(j) ^(k)=ln(α_(j) ^(k)) and β_(j) ^(k)=ln(β_(j) ^(k)) of equations (8) and (9) may be modified based on the merged trellis structure. In the trellis shown in FIG. 2(a) for N=2, for example, the value of the forward probability A₂ ^(k) in equation (8) for state 2 at time k is computed as in equation (11):

A ₂ ^(k)=max*(A ₀ ^(k−2)+{tilde over (Γ)}_(0,2) ^(k) ,A ₂ ^(k−2)+{tilde over (Γ)}_(2,2) ^(k) A ₄ ^(k−2)+{tilde over (Γ)}_(4,2) ^(k) ,A ₆ ^(k−2)+{tilde over (Γ)}_(6,2) ^(k)),  (11)

[0031] When evaluating the max*( ) operation with greater than two values for comparison, such as in equation (11), the operation is carried out iteratively over pairs values.

[0032] The value {tilde over (Γ)}_(i,j) ^(k) is defined as the combined branch metric associated with the transition from state i at time k−2 to state j at time k in the forward direction of the merged trellis (e.g., in FIG. 2 paths traversed in state transitions occurring from left to right). The combined branch metric may be cumulatively computed in the trellis in a manner well known in the art. For example, referring to FIG. 1, the path of the trellis of FIG. 1 that transitions from state 2 at time k−2 to state 0 at time k is state 2 at time k−2 through state 4 at time k−1 to state 0 at time k. For the merged trellis of FIG. 2(a), the branch metric {tilde over (Γ)}_(2,0) ^(k) for the transition from state 2 at time k−2 to state 0 at time k, is the combination of the branch metrics Γ_(2,4) ^(k−1) and Γ_(4,0) ^(k) for the transitions from state 2 at time k−2 to state 4 at time k−1; and from state 4 at time k−1 to state 0 at time k, respectively. Thus, the combined branch metric {tilde over (Γ)}_(2,0) ^(k) from state 2 at time k−2 to state 0 at time k is {tilde over (Γ)}_(2,0) ^(k)=Γ_(2,4) ^(k−1)+Γ_(4,0) ^(k).

[0033] Extending this approach of the N=2 case, the forward recursion equation is then generalized to the N=3 case of FIG. 2(b) as in equation (12):

A _(j) ^(k)=max*_(i=0, 1, , 7)(A _(i) ^(k−3)+{tilde over (Γ)}_(i,j) ^(k)) for j=0, 1, . . . , M−1  (12)

[0034] where the combined branch metric {tilde over (Γ)}_(i,j) ^(k) is obtained by adding three individual branch matrices from time k−3 to time k, and M is the number of states.

[0035] A similar modification employing the techniques described above may be made to the relation of, for example, equation (9) for calculating the backward probability B_(j) ^(k−N). However, the backward probabilities are updated based on traversing the merged trellis in an opposite direction to that traversed when calculating forward probabilities. Consequently, the cumulative branch metric values for transitions are derived in the opposite direction to that of cumulative branch metric values for transitions in the forward direction.

[0036] The block processing technique may be extended to a larger N by combining trellises from time k−N to time k. This technique for generating branch metrics allows for a reduction in the memory space required to store the forward and backward probabilities (state metrics) A_(j) ^(k) and B_(i) ^(k−N) by N.

[0037] When implemented, a MAP algorithm employing a merged trellis structure updates the state metrics to compute α_(j) ^(k) and β_(i) ^(k−N) (or their log values A_(j) ^(k) and B_(i) ^(k−N) for the Log MAP algorithm) based on 1) the current values for the state metrics α_(i) ^(k−N) and β_(i) ^(k) for all i and j (all states in the set S) and 2) the block of N signal input samples [y_(k), y_(k+1), . . . , y_(k+N−1)]. The update operation occurs for each time k=0, N, 2N, . . . L−N+1 and occurs at a rate of 1/N times the rate of processing steps of the prior art trellis of, for example, FIG. 1 (i.e., with a rate of f/N). Thus, the read/write operation for an implementation transfers words of length N for each update operation, but the frequency (and hence, number) of update operations is reduced by a factor of N. Data transfer operations consume relatively high power, and so reducing the number of data transfer operations provides a relative reduction in overall power consumption.

[0038]FIG. 3 shows an exemplary implementation of memory and memory access for a MAP processor operating in accordance with an exemplary embodiment of the present invention. In FIG. 3, MAP processor 301 accesses memory 302 in read/write operations during the forward and backward probability update process. As shown in FIG. 3, memory 302 is divided into blocks [y_(k), y_(k+1), . . . , y_(k+N−1)], k=0, N, . . . , L−N+1, of the input sample sequence [y₀, y₁, . . . , y_(L)].

[0039]FIG. 4 shows an exemplary method of MAP detection by MAP processor 301 including updating forward and backward probabilities in accordance with an exemplary embodiment of the present invention. At step 401, the method retrieves the first block of samples beginning at time k=0 along with the corresponding forward probabilities. At step 402 the forward probabilities are updated, such as the update for forward probability A k for the Log MAP algorithm given in equation (11) for the N=2 case. At step 403, a test determines if the last block of samples (i.e., at time k=L−N+1) has been processed, and if not, the method advances to step 404 to point to the next block of samples in memory. The method then returns to step 401 from step 404 to process the next block.

[0040] If the test of step 403 determines that all forward probabilities have been updated, the methods advances to step 407 to begin the process of updating the backward probabilities. At step 407, the method retrieves the first block of samples beginning at time k=L−N+1 along with the corresponding backward probabilities. At step 408 the backward probabilities are updated. At step 409, a test determines if the last block of samples has been processed, and if not, the method advances to step 412 to point to the next block of samples in memory. The method then returns to step 407 from step 412 to process the next block.

[0041] If the test of step 409 determines that the last block for the current time k has been processed and, so all backward probabilities for each time k have been updated, then the method advances to step 413. At step 413 the MAP algorithm computes the log-likelihoods in accordance with MAP processing algorithms well known in the art.

[0042] Table 1 shows the number of operations per user data for different given values of N in an 8-state trellis, where N=1 is the conventional MAP algorithm of the prior art such as shown in FIG. 1. TABLE 1 Operation N = 1 N = 2 N = 3 addition 8 · 2 = 16 8 · 8/2 = 32 8 · 24/3 = 64 max* 8 8 · 3/2 = 12 8 · 7/3 = 56/3 calculation

[0043] In Table 1, “·” represents multiplication. As shown in Table 1, computational complexity increases with increasing N. However, for typical processing implementations, the power consumption associated with data transfer (read/write) operations is significantly greater than power consumption associated with computational operations.

[0044] While the exemplary embodiments of the present invention have been described with respect to methods implemented within a detector, as would be apparent to one skilled in the art, various functions may be implemented in the digital domain as processing steps in a software program, by digital logic, or in combination of both software and hardware. Such software may be employed in, for example, a digital signal processor, micro-controller or general-purpose computer. Such hardware and software may be embodied within circuits implemented in an integrated circuit.

[0045] The present invention can be embodied in the form of methods and apparatuses for practicing those methods. The present invention can also be embodied in the form of program code embodied in tangible media, such as floppy diskettes, CD-ROMs, hard drives, or any other machine-readable storage medium, wherein, when the program code is loaded into and executed by a machine, such as a computer, the machine becomes an apparatus for practicing the invention. The present invention can also be embodied in the form of program code, for example, whether stored in a storage medium, loaded into and/or executed by a machine, or transmitted over some transmission medium, such as over electrical wiring or cabling, through fiber optics, or via electromagnetic radiation, wherein, when the program code is loaded into and executed by a machine, such as a computer, the machine becomes an apparatus for practicing the invention. When implemented on a general-purpose processor, the program code segments combine with the processor to provide a unique device that operates analogously to specific logic circuits.

[0046] It will be further understood that various changes in the details, materials, and arrangements of the parts which have been described and illustrated in order to explain the nature of this invention may be made by those skilled in the art without departing from the principle and scope of the invention as expressed in the following claims. 

What is claimed is:
 1. A method of generating probabilities to calculate log-likelihood values in a maximum a posteriori (MAP) processor for samples corresponding to data, the method comprising the steps of: (a) retrieving a first block of samples and a corresponding set of forward probabilities, wherein the block of samples correspond to states of a merged trellis, wherein the merged trellis provides combined probabilities of transition from one or more states at k−N, N an integer greater than 1, to current states at time k as the set of forward probabilities; and (b) updating the set of forward probabilities of the merged trellis for the current state at time k, based on the block of samples and the corresponding set of forward probabilities.
 2. The invention as recited in claim 1, further comprising the steps of: (c) retrieving a second block of samples and a corresponding set of backward probabilities, wherein the samples correspond to states of the merged trellis, wherein the merged trellis provides cumulative probabilities of transition from one or more states at time k+N to current states at time k as the set of backward probabilities; and (d) updating the set of backward probabilities of the merged trellis for the current state at time k, based on the block of samples and the corresponding set of backward probabilities.
 3. The invention as recited in claim 2, further comprising the steps of computing log-likelihood values from the updated forward and backward probabilities and generating a data sequence for one or more blocks of samples corresponding to the log-likelihood values.
 4. The invention as recited in claim 1, further comprising the step of storing in or reading from a memory each block of sample values for each update in step (a).
 5. The invention as recited in claim 1, wherein updating the forward probability for a state in step (b) comprises the step of selecting the maximum combined probability for transitions to the current state.
 6. The invention as recited in claim 5, wherein the step of selecting the maximum combined probability for transitions to the current state k is given by: A _(j) ^(k)=max*_(i=0, 1, . . . , 7)(A _(i) ^(k−N)+{tilde over (Γ)}_(i,j) ^(k)) for j=0, 1, . . . , M−1, where {tilde over (Γ)}_(i,j) ^(k) is the combined probability obtained by adding N individual branch matrices from time k−N to time k in an original trellis, and M is the number of states.
 7. The invention as recited in claim 1, wherein the method is employed during a step of either maximum a posteriori (MAP) detection or MAP decoding of received samples.
 8. The invention as recited in claim 1, wherein the method is implemented by a processor in an integrated circuit.
 9. Apparatus generating probabilities to calculate log-likelihood values corresponding to data, the apparatus comprising: a maximum a posteriori (MAP) processor comprising: a first module retrieving a first block of samples and a corresponding set of forward probabilities, wherein the block of samples correspond to states of a merged trellis, wherein the merged trellis provides combined probabilities of transition from one or more states at k−N, N an integer greater than 1, to current states at time k as the set of forward probabilities; and a second module updating the set of forward probabilities of the merged trellis for the current state at time k, based on the block of samples and the corresponding set of forward probabilities.
 10. The invention as recited in claim 9, wherein the MAP processor further comprises: a third module retrieving a second block of samples and a corresponding set of backward probabilities, wherein the samples correspond to states of the merged trellis, wherein the merged trellis provides cumulative probabilities of transition from one or more states at time k+N to current states at time k as the set of backward probabilities; and a fourth module updating the set of backward probabilities of the merged trellis for the current state at time k, based on the block of samples and the corresponding set of backward probabilities.
 11. The invention as recited in claim 10, wherein the MAP processor is configured to 1) compute log-likelihood values from the updated forward and backward probabilities and 2) generate a data sequence for one or more blocks of samples corresponding to the log-likelihood values.
 12. The invention as recited in claim 9, further comprising a memory, wherein the MAP processor stores in or reads from the memory each block of sample values for each update.
 13. The invention as recited in claim 9, wherein the second module updates the forward probability for a state by selecting the maximum combined probability for transitions to the current state.
 14. The invention as recited in claim 13, wherein selecting the maximum combined probability for transitions to the current state k is given by: A _(j) ^(k)=max*_(i=0, 1, . . . , 7)(A _(i) ^(k−N)+{tilde over (Γ)}_(i,j) ^(k)) for j=0, 1, . . . , M−1, where {tilde over (Γ)}_(i,j) ^(k) is the combined probability obtained by adding N individual branch matrices from time k−N to time k in an original trellis, and M is the number of states.
 15. The invention as recited in claim 9, wherein the apparatus is a circuit embodied in an integrated circuit.
 16. A computer-readable medium having stored thereon a plurality of instructions, the plurality of instructions including instructions which, when executed by a processor, cause the processor to implement a method for generating log-likelihood values for data in a maximum a posteriori (MAP) processor, the method comprising the steps of: (a) retrieving a first block of samples and a corresponding set of forward probabilities, wherein the block of samples correspond to states of a merged trellis, wherein the merged trellis provides combined probabilities of transition from one or more states at k−N, N an integer greater than 1, to current states at time k as the set of forward probabilities; and (b) updating the set of forward probabilities of the merged trellis for the current state at time k, based on the block of samples and the corresponding set of forward probabilities.
 17. The invention as recited in claim 16, further comprising the steps of: (c) retrieving a second block of samples and a corresponding set of backward probabilities, wherein the samples correspond to states of the merged trellis, wherein the merged trellis provides cumulative probabilities of transition from one or more states at time k+N to current states at time k as the set of backward probabilities; and (d) updating the set of backward probabilities of the merged trellis for the current state at time k, based on the block of samples and the corresponding set of backward probabilities. 